{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:37:17.641880200Z",
     "start_time": "2023-09-06T05:37:17.631887Z"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install PyVirtualDisplay==3.0\n",
    "    !pip install gymnasium==0.28.1\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 06. Categorical DQN\n",
    "\n",
    "[M. G. Bellemare et al., \"A Distributional Perspective on Reinforcement Learning.\" arXiv preprint arXiv:1707.06887, 2017.](https://arxiv.org/pdf/1707.06887.pdf)\n",
    "\n",
    "The authors argued the importance of learning the distribution of returns instead of the expected return, and they proposed to model such distributions with probability masses placed on a discrete support $z$, where $z$ is a vector with $N_{atoms} \\in \\mathbb{N}^+$ atoms, defined by $z_i = V_{min} + (i-1) \\frac{V_{max} - V_{min}}{N-1}$ for $i \\in \\{1, ..., N_{atoms}\\}$.\n",
    "\n",
    "The key insight is that return distributions satisfy a variant of Bellman’s equation. For a given state $S_t$ and action $A_t$, the distribution of the returns under the optimal policy $\\pi^{*}$ should match a target distribution defined by taking the distribution for the next state $S_{t+1}$ and action $a^{*}_{t+1} = \\pi^{*}(S_{t+1})$, contracting\n",
    "it towards zero according to the discount, and shifting it by the reward (or distribution of rewards, in the stochastic case). A distributional variant of Q-learning is then derived by first constructing a new support for the target distribution, and then minimizing the Kullbeck-Leibler divergence between the distribution $d_t$ and the target distribution\n",
    "\n",
    "$$\n",
    "d_t' = (R_{t+1} + \\gamma_{t+1} z, p_\\hat{{\\theta}} (S_{t+1}, \\hat{a}^{*}_{t+1})),\\\\\n",
    "D_{KL} (\\phi_z d_t' \\| d_t).\n",
    "$$\n",
    "\n",
    "Here $\\phi_z$ is a L2-projection of the target distribution onto the fixed support $z$, and $\\hat{a}^*_{t+1} = \\arg\\max_{a} q_{\\hat{\\theta}} (S_{t+1}, a)$ is the greedy action with respect to the mean action values $q_{\\hat{\\theta}} (S_{t+1}, a) = z^{T}p_{\\theta}(S_{t+1}, a)$ in state $S_{t+1}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:37:17.657890200Z",
     "start_time": "2023-09-06T05:37:17.644880200Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:37:17.675904Z",
     "start_time": "2023-09-06T05:37:17.664932300Z"
    }
   },
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self, \n",
    "        obs: np.ndarray, \n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "The parametrized distribution can be represented by a neural network, as in DQN, but with atom_size x out_dim outputs. A softmax is applied independently for each action dimension of the output to ensure that the distribution for each action is appropriately normalized.\n",
    "\n",
    "To estimate q-values, we use inner product of each action's softmax distribution and support which is the set of atoms $\\{z_i = V_{min} + i\\Delta z: 0 \\le i < N\\}, \\Delta z = \\frac{V_{max} - V_{min}}{N-1}$.\n",
    "\n",
    "$$\n",
    "Q(s_t, a_t) = \\sum_i z_i p_i(s_t, a_t), \\\\\n",
    "\\text{where } p_i \\text{ is the probability of } z_i \\text{ (the output of softmax)}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:37:17.690887400Z",
     "start_time": "2023-09-06T05:37:17.677886400Z"
    }
   },
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(\n",
    "        self, \n",
    "        in_dim: int, \n",
    "        out_dim: int, \n",
    "        atom_size: int, \n",
    "        support: torch.Tensor\n",
    "    ):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.support = support\n",
    "        self.out_dim = out_dim\n",
    "        self.atom_size = atom_size\n",
    "        \n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim * atom_size)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        dist = self.dist(x)\n",
    "        q = torch.sum(dist * self.support, dim=2)\n",
    "        \n",
    "        return q\n",
    "    \n",
    "    def dist(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Get distribution for atoms.\"\"\"\n",
    "        q_atoms = self.layers(x).view(-1, self.out_dim, self.atom_size)\n",
    "        dist = F.softmax(q_atoms, dim=-1)\n",
    "        dist = dist.clamp(min=1e-3)  # for avoiding nans\n",
    "        \n",
    "        return dist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Categorical DQN Agent\n",
    "\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "All differences from pure DQN are noted with comments *Categorical DQN*.\n",
    "\n",
    "核心差异在计算 loss 的过程。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:37:17.724039500Z",
     "start_time": "2023-09-06T05:37:17.691896600Z"
    }
   },
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including\n",
    "                           state, action, reward, next_state, done\n",
    "        v_min (float): min value of support\n",
    "        v_max (float): max value of support\n",
    "        atom_size (int): the unit number of support\n",
    "        support (torch.Tensor): support for categorical dqn\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        seed: int,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "        # Categorical DQN parameters\n",
    "        v_min: float = 0.0,\n",
    "        v_max: float = 200.0,\n",
    "        atom_size: int = 51,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "            v_min (float): min value of support\n",
    "            v_max (float): max value of support\n",
    "            atom_size (int): the unit number of support\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.seed = seed\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "        print(self.device)\n",
    "        \n",
    "        # Categorical DQN parameters\n",
    "        self.v_min = v_min\n",
    "        self.v_max = v_max\n",
    "        self.atom_size = atom_size\n",
    "        self.support = torch.linspace(\n",
    "            self.v_min, self.v_max, self.atom_size\n",
    "        ).to(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(\n",
    "            obs_dim, action_dim, atom_size, self.support\n",
    "        ).to(self.device)\n",
    "        self.dqn_target = Network(\n",
    "            obs_dim, action_dim, atom_size, self.support\n",
    "        ).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device),\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state, _ = self.env.reset(seed=self.seed)\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        # reset\n",
    "        self.env = naive_env\n",
    "\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return categorical dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"]).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # Categorical DQN algorithm\n",
    "        delta_z = float(self.v_max - self.v_min) / (self.atom_size - 1)\n",
    "\n",
    "        with torch.no_grad():\n",
    "            next_action = self.dqn_target(next_state).argmax(1)\n",
    "            next_dist = self.dqn_target.dist(next_state)\n",
    "            next_dist = next_dist[range(self.batch_size), next_action]\n",
    "\n",
    "            t_z = reward + (1 - done) * self.gamma * self.support\n",
    "            t_z = t_z.clamp(min=self.v_min, max=self.v_max)\n",
    "            b = (t_z - self.v_min) / delta_z\n",
    "            l = b.floor().long()\n",
    "            u = b.ceil().long()\n",
    "\n",
    "            offset = (\n",
    "                torch.linspace(\n",
    "                    0, (self.batch_size - 1) * self.atom_size, self.batch_size\n",
    "                ).long()\n",
    "                .unsqueeze(1)\n",
    "                .expand(self.batch_size, self.atom_size)\n",
    "                .to(self.device)\n",
    "            )\n",
    "\n",
    "            proj_dist = torch.zeros(next_dist.size(), device=self.device)\n",
    "            proj_dist.view(-1).index_add_(\n",
    "                0, (l + offset).view(-1), (next_dist * (u.float() - b)).view(-1)\n",
    "            )\n",
    "            proj_dist.view(-1).index_add_(\n",
    "                0, (u + offset).view(-1), (next_dist * (b - l.float())).view(-1)\n",
    "            )\n",
    "\n",
    "        dist = self.dqn.dist(state)\n",
    "        log_p = torch.log(dist[range(self.batch_size), action])\n",
    "\n",
    "        loss = -(proj_dist * log_p).sum(1).mean()\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:37:17.739016800Z",
     "start_time": "2023-09-06T05:37:17.724039500Z"
    }
   },
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=200, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:37:17.755016300Z",
     "start_time": "2023-09-06T05:37:17.740016800Z"
    }
   },
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:37:17.813036100Z",
     "start_time": "2023-09-06T05:37:17.757016400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 10000\n",
    "memory_size = 2000\n",
    "batch_size = 32\n",
    "target_update = 150\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 2000x500 with 3 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:38:04.721153100Z",
     "start_time": "2023-09-06T05:38:03.731308800Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\18213\\anaconda3\\envs\\Rainbow\\lib\\site-packages\\gymnasium\\wrappers\\record_video.py:87: UserWarning: \u001B[33mWARN: Overwriting existing videos at C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\categorical_dqn folder (try specifying a different `video_folder` for the `RecordVideo` wrapper if this is not desired)\u001B[0m\n",
      "  logger.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\categorical_dqn\\rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\categorical_dqn\\rl-video-episode-0.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\categorical_dqn\\rl-video-episode-0.mp4\n",
      "score:  200.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/categorical_dqn\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:38:04.735153500Z",
     "start_time": "2023-09-06T05:38:04.693153600Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<IPython.core.display.HTML object>",
      "text/html": "\n        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n        </video>\n        "
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/categorical_dqn\\rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "language": "python",
   "display_name": "Python 3 (ipykernel)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
